package com.ms.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ms.dao.ManagerMapper;
import com.ms.entity.Manager;
import com.ms.service.inter.ManagerService;
import com.ms.utils.SimpleTokenUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Service 实现类，继承 ServiceImpl 并实现自定义接口
 */
@Service // 标记为 Spring 服务组件，用于依赖注入
public class ManagerServiceImpl extends ServiceImpl<ManagerMapper, Manager> implements ManagerService {

    // 密码盐值
    private static final String PASSWORD_SALT = "sports_admin_2025";

    // 实现接口中的自定义方法
    @Override
    public List<Manager> getMainManagers() {
        // 调用 MyBatis-Plus 的条件构造器 QueryWrapper 构建查询条件
        QueryWrapper<Manager> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("ma_isMain", true); // 查询 ma_isMain 为 true 的记录

        return this.list(queryWrapper);
    }

    // 根据账号查询管理员信息
    @Override
    public Manager getManagerByAccount(String account) {
        // 使用 QueryWrapper 构造查询条件
        QueryWrapper<Manager> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("ma_account", account); // 数据库字段名为 ma_account

        // 调用基类的 getOne 方法查询单个管理员信息
        return this.getOne(queryWrapper);
    }

    // 更新管理员在线状态
    @Override
    public boolean updateManagerOnlineStatus(Integer Id, boolean isUsing) {
        // 创建 UpdateWrapper 设置更新条件和字段
        UpdateWrapper<Manager> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("ma_id", Id); // 假设主键字段名为 ma_id
        updateWrapper.set("ma_isUsing", isUsing); // 假设在线状态字段名为 ma_isUsing

        // 调用父类的 update 方法执行更新操作
        return this.update(updateWrapper);
    }


    // 创建管理员账号
    @Override
    public boolean createManager(Manager manager) {
        // 验证账号是否已存在
        Manager existingManager = this.getManagerByAccount(manager.getMaAccount());
        if (existingManager != null) {
            return false; // 账号已存在，创建失败
        }

        // 设置默认值
        manager.setMaIsMain(false); // 新创建的管理员默认不是主管理员
        manager.setMaIsUsing(true); // 默认在线状态为使用中

        // 保存管理员信息
        return this.save(manager);
    }

    @Override
    public Map<String, Object> login(String account, String password, String ip) {
        Map<String, Object> result = new HashMap<>();

        try {
            // 根据账号查找管理员
            Manager manager = this.baseMapper.selectByAccount(account);
            if (manager == null) {
                result.put("success", false);
                result.put("message", "管理员账号不存在");
                return result;
            }

            // 验证密码（支持明文密码）
            if (!manager.getMaPassword().equals(password)) {
                result.put("success", false);
                result.put("message", "密码错误");
                return result;
            }

            // 检查账号状态
            if (!manager.getMaIsUsing()) {
                result.put("success", false);
                result.put("message", "账号已被禁用，请联系主管理员");
                return result;
            }

            // 更新最后登录信息
            manager.setMaTime(LocalDateTime.now());
            this.updateById(manager);

            // 生成token
            String token = SimpleTokenUtils.generateToken(manager);

            // 返回结果
            result.put("success", true);
            result.put("message", "登录成功");
            result.put("token", token);
            result.put("manager", getSafeManagerInfo(manager));

        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "登录失败：" + e.getMessage());
        }

        return result;
    }

    @Override
    public boolean register(Manager manager, Integer creatorId) {
        try {
            // 检查账号是否已存在
            QueryWrapper<Manager> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("ma_account", manager.getMaAccount());
            if (this.getOne(queryWrapper) != null) {
                throw new RuntimeException("账号已存在");
            }

            // 不加密密码，直接保存
            return this.save(manager);
        } catch (Exception e) {
            throw new RuntimeException("注册失败：" + e.getMessage());
        }
    }

    @Override
    public boolean changeStatus(Integer managerId, Integer status, Integer operatorId) {
        try {
            Manager manager = this.getById(managerId);
            if (manager == null) {
                throw new RuntimeException("管理员不存在");
            }

            // 不能操作自己
            if (managerId.equals(operatorId)) {
                throw new RuntimeException("不能操作自己的账号");
            }

            manager.setMaIsUsing(status == 1); // 状态1为启用，0为禁用
            return this.updateById(manager);
        } catch (Exception e) {
            throw new RuntimeException("修改状态失败：" + e.getMessage());
        }
    }

    @Override
    public boolean changePassword(Integer managerId, String oldPassword, String newPassword) {
        try {
            Manager manager = this.getById(managerId);
            if (manager == null) {
                throw new RuntimeException("管理员不存在");
            }

            // 验证旧密码（支持明文密码）
            if (!manager.getMaPassword().equals(oldPassword)) {
                throw new RuntimeException("旧密码错误");
            }

            manager.setMaPassword(newPassword);
            return this.updateById(manager);
        } catch (Exception e) {
            throw new RuntimeException("修改密码失败：" + e.getMessage());
        }
    }

    @Override
    public List<Manager> getManagersByIsMain(Boolean isMain) {
        QueryWrapper<Manager> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("ma_isMain", isMain).eq("ma_isUsing", true);
        return this.list(queryWrapper);
    }

    @Override
    public boolean resetPassword(Integer managerId, Integer operatorId) {
        try {
            Manager manager = this.getById(managerId);
            if (manager == null) {
                throw new RuntimeException("管理员不存在");
            }

            // 默认重置密码为123456（明文存储）
            manager.setMaPassword("123456");
            return this.updateById(manager);
        } catch (Exception e) {
            throw new RuntimeException("重置密码失败：" + e.getMessage());
        }
    }

    @Override
    public Manager getManagerInfo(Integer managerId) {
        Manager manager = this.getById(managerId);
        return getSafeManagerInfo(manager);
    }

    /**
     * 密码加密
     */
    private String encryptPassword(String password) {
        return DigestUtils.md5DigestAsHex((password + PASSWORD_SALT).getBytes());
    }

    /**
     * 获取所有管理员
     * @return 管理员列表
     */
    @Override
    public List<Manager> findAll() {
        try {
            // 使用MyBatis-Plus的查询方法
            return this.baseMapper.selectList(null);
        } catch (Exception e) {
            throw new RuntimeException("获取所有管理员失败: " + e.getMessage(), e);
        }
    }

    /**
     * 主管理员更新普通管理员信息
     * @param manager 管理员信息
     * @return 更新结果
     */
    @Override
    public boolean updateManagerInfo(Manager manager) {
        // 检查要更新的管理员是否存在
        Manager existingManager = this.getById(manager.getMaId());
        if (existingManager == null) {
            return false; // 管理员不存在
        }

        // 检查是否试图将普通管理员修改为主管理员
        if (manager.getMaIsMain() != null && manager.getMaIsMain() && !existingManager.getMaIsMain()) {
            return false; // 不允许将普通管理员设置为主管理员
        }

        // 更新管理员信息
        return this.updateById(manager);
    }
    /**
     * 获取安全的管理员信息（排除密码等敏感信息）
     */
    private Manager getSafeManagerInfo(Manager manager) {
        if (manager == null) return null;

        // 使用setter方法设置属性，而不是构造函数
        Manager safeManager = new Manager();
        safeManager.setMaId(manager.getMaId());
        safeManager.setMaName(manager.getMaName());
        safeManager.setMaAccount(manager.getMaAccount());
        safeManager.setMaIsMain(manager.getMaIsMain());
        safeManager.setMaIsUsing(manager.getMaIsUsing());
        safeManager.setMaTime(manager.getMaTime());

        return safeManager;
    }
}